home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt3sp2.arc / PIBANSIB.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1985-10-04  |  51.6 KB  |  1,411 lines
  1. (*----------------------------------------------------------------------*)
  2. (*             Ansi_Set_Graphics --- Set graphics display               *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Ansi_Set_Graphics;
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Procedure: Ansi_Set_Graphics                                     *)
  10. (*                                                                      *)
  11. (*     Purpose:   Sets graphics rendition modes for ANSI/VT100          *)
  12. (*                                                                      *)
  13. (*     Calling Sequence:                                                *)
  14. (*                                                                      *)
  15. (*        Ansi_Set_Graphics;                                            *)
  16. (*                                                                      *)
  17. (*     Calls:                                                           *)
  18. (*                                                                      *)
  19. (*        TextColor                                                     *)
  20. (*        TextBackGround                                                *)
  21. (*                                                                      *)
  22. (*     Called by:  VT100_Process_Escape                                 *)
  23. (*                 Ansi_Process_Escape                                  *)
  24. (*                                                                      *)
  25. (*----------------------------------------------------------------------*)
  26.  
  27. VAR
  28.    I     : INTEGER;
  29.    J     : INTEGER;
  30.  
  31. BEGIN (* Ansi_Set_Graphics *)
  32.  
  33.    FG  := Ansi_Foreground_Color;
  34.    BG  := Ansi_Background_Color;
  35.  
  36.    IF ( Escape_Number = 0 ) THEN
  37.       BEGIN
  38.          Escape_Number      := 1;
  39.          Escape_Register[1] := 0;
  40.       END;
  41.  
  42.    FOR I := 1 TO Escape_Number DO
  43.       BEGIN
  44.  
  45.          CASE Escape_Register[I] OF
  46.  
  47.             0 : BEGIN
  48.                    White_Shade := Ansi_ForeGround_Color;
  49.                    FG          := White_Shade;
  50.                    BG          := Ansi_BackGround_Color;
  51.                 END;
  52.  
  53.             1 : BEGIN
  54.                    White_Shade := Ansi_Bold_Color;
  55.                    FG          := White_Shade;
  56.                 END;
  57.  
  58.             4 : BEGIN
  59.                                    (* NOTE: In mono mode BLUE will    *)
  60.                                    (* correctly produce an underline. *)
  61.  
  62.                    FG := Ansi_Underline_Color;
  63.  
  64.                 END;
  65.  
  66.             5 : FG := FG + Blink;
  67.  
  68.             7 : BEGIN
  69.                    FG := Ansi_BackGround_Color;
  70.                    BG := Ansi_ForeGround_Color;
  71.                 END;
  72.  
  73.             8 : FG := BG;
  74.  
  75.            30 : FG := BLACK;
  76.  
  77.            31 : IF ( Text_Mode = C80 ) THEN FG := RED;
  78.  
  79.            32 : IF ( Text_Mode = C80 ) THEN FG := GREEN;
  80.  
  81.            33 : IF ( Text_Mode = C80 ) THEN FG := YELLOW;
  82.  
  83.            34 : IF ( Text_Mode = C80 ) THEN FG := BLUE;
  84.  
  85.            35 : IF ( Text_Mode = C80 ) THEN FG := MAGENTA;
  86.  
  87.            36 : IF ( Text_Mode = C80 ) THEN FG := CYAN;
  88.  
  89.            37 : IF ( Text_Mode = C80 ) THEN FG := White_Shade;
  90.  
  91.            40 : BG := BLACK;
  92.  
  93.            41 : IF ( Text_Mode = C80 ) THEN BG := RED;
  94.  
  95.            42 : IF ( Text_Mode = C80 ) THEN BG := GREEN;
  96.  
  97.            43 : IF ( Text_Mode = C80 ) THEN BG := YELLOW;
  98.  
  99.            44 : IF ( Text_Mode = C80 ) THEN BG := BLUE;
  100.  
  101.            45 : IF ( Text_Mode = C80 ) THEN BG := MAGENTA;
  102.  
  103.            46 : IF ( Text_Mode = C80 ) THEN BG := CYAN;
  104.  
  105.            47 : BG := White_Shade;
  106.  
  107.          END (* CASE *);
  108.  
  109.       END;
  110.                                    (* Change the colors *)
  111.    TextColor     ( FG );
  112.    TextBackGround( BG );
  113.  
  114. END   (* Ansi_Set_Graphics *);
  115.  
  116. (*----------------------------------------------------------------------*)
  117. (*             Ansi_Set_Cursor --- Set cursor position                  *)
  118. (*----------------------------------------------------------------------*)
  119.  
  120. PROCEDURE Ansi_Set_Cursor;
  121.  
  122. (*----------------------------------------------------------------------*)
  123. (*                                                                      *)
  124. (*     Procedure: Ansi_Set_Cursor                                       *)
  125. (*                                                                      *)
  126. (*     Purpose:   Sets cursor position                                  *)
  127. (*                                                                      *)
  128. (*     Calling Sequence:                                                *)
  129. (*                                                                      *)
  130. (*        Ansi_Set_Cursor;                                              *)
  131. (*                                                                      *)
  132. (*     Calls:                                                           *)
  133. (*                                                                      *)
  134. (*        Max                                                           *)
  135. (*        Min                                                           *)
  136. (*        UpperLeft                                                     *)
  137. (*                                                                      *)
  138. (*     Called by:  VT100_Process_Escape                                 *)
  139. (*                 Ansi_Process_Escape                                  *)
  140. (*                                                                      *)
  141. (*----------------------------------------------------------------------*)
  142.  
  143. VAR
  144.    Row:     INTEGER;
  145.    Col:     INTEGER;
  146.  
  147. BEGIN (* Ansi_Set_Cursor *)
  148.  
  149.    CASE Escape_Number OF
  150.                                    (* Home cursor if no coords given *)
  151.       0 : BEGIN
  152.              Row := 1;
  153.              Col := 1;
  154.           END;
  155.                                    (* Column 1 is default, row provided *)
  156.       1 : BEGIN
  157.              Col := 1;
  158.              Row := Escape_Register[1];
  159.           END;
  160.                                    (* Both row and column provided *)
  161.       ELSE
  162.              Col := Escape_Register[2];
  163.              Row := Escape_Register[1];
  164.  
  165.    END;
  166.  
  167.    Row := MAX( MIN( Row , 25 ) , 1 );
  168.    Col := MAX( MIN( Col , 80 ) , 1 );
  169.  
  170.                                    (* Move to new coordinates *)
  171.    GoToXY( Col , Row );
  172.  
  173. END   (* Ansi_Set_Cursor *);
  174.  
  175. (*----------------------------------------------------------------------*)
  176. (*             Ansi_Clear_Screen --- Clear segment of screen            *)
  177. (*----------------------------------------------------------------------*)
  178.  
  179. PROCEDURE Ansi_Clear_Screen;
  180.  
  181. (*----------------------------------------------------------------------*)
  182. (*                                                                      *)
  183. (*     Procedure: Ansi_Clear_Screen                                     *)
  184. (*                                                                      *)
  185. (*     Purpose:   Clears portion of screen                              *)
  186. (*                                                                      *)
  187. (*     Calling Sequence:                                                *)
  188. (*                                                                      *)
  189. (*        Ansi_Clear_Screen;                                            *)
  190. (*                                                                      *)
  191. (*     Called by:  VT100_Process_Escape                                 *)
  192. (*                 Ansi_Process_Escape                                  *)
  193. (*                                                                      *)
  194. (*----------------------------------------------------------------------*)
  195.  
  196. VAR
  197.    I:        INTEGER;
  198.    X:        INTEGER;
  199.    Y:        INTEGER;
  200.    C:        INTEGER;
  201.    Save_FG1: INTEGER;
  202.    Save_BG1: INTEGER;
  203.  
  204. BEGIN (* Ansi_Clear_Screen *)
  205.  
  206.    IF ( Escape_Number = 1 )  THEN
  207.       C := Escape_Register[1]
  208.    ELSE
  209.       C := 0;
  210.  
  211.    Save_FG1 := FG;
  212.    Save_BG1 := BG;
  213.  
  214.    TextColor     ( Ansi_ForeGround_Color );
  215.    TextBackGround( Ansi_BackGround_Color );
  216.  
  217.    CASE C OF
  218.                                    (* Clear from cursor position to *)
  219.                                    (* end of screen                 *)
  220.       0:  BEGIN
  221.  
  222.              X := WhereX;
  223.              Y := WhereY;
  224.  
  225.              ClrEol;
  226.  
  227.              FOR I := ( Y + 1 ) TO 25 DO
  228.                 BEGIN
  229.                    GoToXY( 1 , I );
  230.                    ClrEol;
  231.                 END;
  232.  
  233.              GoToXY( X , Y );
  234.  
  235.           END;
  236.                                    (* Clear start of screen to current *)
  237.                                    (* cursor position                  *)
  238.       1:  BEGIN
  239.  
  240.              X     := WhereX;
  241.              Y     := WhereY;
  242.  
  243.              FOR I := 1 TO ( Y - 1 ) DO
  244.                 DelLine;
  245.  
  246.              FOR I := 1 TO X DO
  247.                 WRITE(' ');
  248.  
  249.           END;
  250.                                    (* Clear entire screen *)
  251.       2:  ClrScr;
  252.  
  253.    END (* CASE *);
  254.  
  255.    TextColor     ( Save_FG1 );
  256.    TextBackGround( Save_BG1 );
  257.  
  258. END   (* Ansi_Clear_Screen *);
  259.  
  260. (*----------------------------------------------------------------------*)
  261. (*             Ansi_Clear_Line --- Clear part of line in display        *)
  262. (*----------------------------------------------------------------------*)
  263.  
  264. PROCEDURE Ansi_Clear_Line;
  265.  
  266. (*----------------------------------------------------------------------*)
  267. (*                                                                      *)
  268. (*     Procedure: Ansi_Clear_Line                                       *)
  269. (*                                                                      *)
  270. (*     Purpose:   Clears portion of current line                        *)
  271. (*                                                                      *)
  272. (*     Calling Sequence:                                                *)
  273. (*                                                                      *)
  274. (*        Ansi_Clear_Line;                                              *)
  275. (*                                                                      *)
  276. (*     Called by:  VT100_Process_Escape                                 *)
  277. (*                 Ansi_Process_Escape                                  *)
  278. (*                                                                      *)
  279. (*----------------------------------------------------------------------*)
  280.  
  281. VAR
  282.    I:        INTEGER;
  283.    X:        INTEGER;
  284.    Y:        INTEGER;
  285.    C:        INTEGER;
  286.    Save_FG1: INTEGER;
  287.    Save_BG1: INTEGER;
  288.  
  289. BEGIN (* Ansi_Clear_Line *)
  290.  
  291.    IF ( Escape_Number = 1 )  THEN
  292.       C := Escape_Register[1]
  293.    ELSE
  294.       C := 0;
  295.  
  296.    Save_FG1 := FG;
  297.    Save_BG1 := BG;
  298.  
  299.    TextColor     ( Ansi_ForeGround_Color );
  300.    TextBackGround( Ansi_BackGround_Color );
  301.  
  302.    CASE C OF
  303.  
  304.                                    (* Clear cursor to end *)
  305.       0:  ClrEol;
  306.                                    (* Clear start to cursor *)
  307.       1:  BEGIN
  308.              X := WhereX;
  309.              Y := WhereY;
  310.              GoToXY( 1 , Y );
  311.              FOR I := 1 TO X DO
  312.                 WRITE(' ');
  313.           END;
  314.                                    (* Clear entire line *)
  315.       2:  BEGIN
  316.              Y := WhereY;
  317.              GoToXY( 1 , Y );
  318.              ClrEol;
  319.           END;
  320.  
  321.    END  (* CASE *);
  322.  
  323.    TextColor     ( Save_FG1 );
  324.    TextBackGround( Save_BG1 );
  325.  
  326. END   (* Ansi_Clear_Line *);
  327.  
  328. (*----------------------------------------------------------------------*)
  329. (*          Ansi_Write_Escape --- Write out escape sequence to display  *)
  330. (*----------------------------------------------------------------------*)
  331.  
  332. PROCEDURE Ansi_Write_Escape;
  333.  
  334. (*----------------------------------------------------------------------*)
  335. (*                                                                      *)
  336. (*     Procedure: Ansi_Write_Escape                                     *)
  337. (*                                                                      *)
  338. (*     Purpose:   Writes unused escape sequence chars to display        *)
  339. (*                                                                      *)
  340. (*     Calling Sequence:                                                *)
  341. (*                                                                      *)
  342. (*        Ansi_Write_Escape;                                            *)
  343. (*                                                                      *)
  344. (*     Called by:  VT100_Process_Escape                                 *)
  345. (*                 Ansi_Process_Escape                                  *)
  346. (*                                                                      *)
  347. (*----------------------------------------------------------------------*)
  348.  
  349. VAR
  350.    I: INTEGER;
  351.  
  352. BEGIN (* Ansi_Write_Escape *)
  353.  
  354.    FOR I := 1 TO LENGTH( Escape_Str ) DO
  355.       Display_Character( Escape_Str[I] );
  356.  
  357.    Escape_Type    := ' ';
  358.  
  359. END   (* Ansi_Write_Escape *);
  360.  
  361. (*----------------------------------------------------------------------*)
  362. (*            Ansi_Next_Char --- Get next character in escape sequence  *)
  363. (*----------------------------------------------------------------------*)
  364.  
  365. FUNCTION Ansi_Next_Char : CHAR;
  366.  
  367. (*----------------------------------------------------------------------*)
  368. (*                                                                      *)
  369. (*     Function: Ansi_Next_Char                                         *)
  370. (*                                                                      *)
  371. (*     Purpose:  Waits for next character in escape sequence            *)
  372. (*                                                                      *)
  373. (*     Calling Sequence:                                                *)
  374. (*                                                                      *)
  375. (*        Ansi_Next_Char;                                               *)
  376. (*                                                                      *)
  377. (*     Called by:  VT100_Process_Escape                                 *)
  378. (*                 Ansi_Process_Escape                                  *)
  379. (*                                                                      *)
  380. (*     Remarks:                                                         *)
  381. (*                                                                      *)
  382. (*        This routine actually shouldn't be used, but I got lazy.      *)
  383. (*        Needs to be fixed next time around.                           *)
  384. (*                                                                      *)
  385. (*----------------------------------------------------------------------*)
  386.  
  387. VAR
  388.    Next_Ch: INTEGER;
  389.  
  390. BEGIN (* Ansi_Next_Char *)
  391.  
  392.    Async_Receive_With_Timeout( 1 , Next_Ch );
  393.  
  394.    IF Next_Ch > 0 THEN
  395.       Ansi_Next_Char := CHR( Next_Ch )
  396.    ELSE
  397.       Ansi_Next_Char := CHR( 0 );
  398.  
  399. END   (* Ansi_Next_Char *);
  400.  
  401. (*----------------------------------------------------------------------*)
  402. (*      Ansi_Set_Scrolling_Region --- Set scrolling region (window)     *)
  403. (*----------------------------------------------------------------------*)
  404.  
  405. PROCEDURE Ansi_Set_Scrolling_Region;
  406.  
  407. (*----------------------------------------------------------------------*)
  408. (*                                                                      *)
  409. (*     Procedure: Ansi_Set_Scrolling_Region                             *)
  410. (*                                                                      *)
  411. (*     Purpose:   Sets scrolling region (window)                        *)
  412. (*                                                                      *)
  413. (*     Calling Sequence:                                                *)
  414. (*                                                                      *)
  415. (*        Ansi_Set_Scrolling_Region;                                    *)
  416. (*                                                                      *)
  417. (*     Called by:  VT100_Process_Escape                                 *)
  418. (*                 Ansi_Process_Escape                                  *)
  419. (*                                                                      *)
  420. (*----------------------------------------------------------------------*)
  421.  
  422. VAR
  423.    Top:    INTEGER;
  424.    Bottom: INTEGER;
  425.  
  426. BEGIN (* Ansi_Set_Scrolling_Region *)
  427.  
  428.    CASE Escape_Number OF
  429.                                    (* Window is entire screen *)
  430.       0:  BEGIN
  431.              Top    := 1;
  432.              Bottom := 25;
  433.           END;
  434.                                    (* From specified line to end of screen *)
  435.       1:  BEGIN
  436.              Top    := MAX( Escape_Register[1] , 1 );
  437.              Bottom := 25;
  438.           END;
  439.                                    (* Both top and bottom specified *)
  440.       2:  BEGIN
  441.              Top    := MAX( Escape_Register[1] , 1  );
  442.              Bottom := MIN( Escape_Register[2] , 25 );
  443.           END;
  444.  
  445.       ELSE
  446.              Top    := MAX( Escape_Register[1] , 1  );
  447.              Bottom := MIN( Escape_Register[2] , 25 );
  448.  
  449.    END (* CASE *);
  450.  
  451.    IF Bottom < Top THEN Bottom := 25;
  452.  
  453.    GoToXY( 1 , 1 );
  454.  
  455.    Top_Scroll    := Top;
  456.    Bottom_Scroll := Bottom;
  457.  
  458. END   (* Ansi_Set_Scrolling_Region *);
  459.  
  460. (*----------------------------------------------------------------------*)
  461. (*                    Ansi_Cursor_Up --- Move cursor up                 *)
  462. (*----------------------------------------------------------------------*)
  463.  
  464. PROCEDURE Ansi_Cursor_Up;
  465.  
  466. (*----------------------------------------------------------------------*)
  467. (*                                                                      *)
  468. (*     Procedure: Ansi_Cursor_Up;                                       *)
  469. (*                                                                      *)
  470. (*     Purpose:   Moves cursor up specified number of lines             *)
  471. (*                                                                      *)
  472. (*     Calling Sequence:                                                *)
  473. (*                                                                      *)
  474. (*        Ansi_Cursor_Up;                                               *)
  475. (*                                                                      *)
  476. (*     Called by:  VT100_Process_Escape                                 *)
  477. (*                                                                      *)
  478. (*----------------------------------------------------------------------*)
  479.  
  480. BEGIN (* Ansi_Cursor_Up *)
  481.  
  482.    IF Escape_Number = 0 THEN
  483.       Reg_Val := 1
  484.    ELSE
  485.       Reg_Val := MAX( 1 , Escape_Register[1] );
  486.  
  487.    GoToXY( Wherex, MAX( WhereY - Reg_Val , 1 ) );
  488.  
  489. END   (* Ansi_Cursor_Up *);
  490.  
  491. (*----------------------------------------------------------------------*)
  492. (*                 Ansi_Cursor_Down --- Move cursor down                *)
  493. (*----------------------------------------------------------------------*)
  494.  
  495. PROCEDURE Ansi_Cursor_Down;
  496.  
  497. (*----------------------------------------------------------------------*)
  498. (*                                                                      *)
  499. (*     Procedure: Ansi_Cursor_Down;                                     *)
  500. (*                                                                      *)
  501. (*     Purpose:   Moves cursor down specified number of lines           *)
  502. (*                                                                      *)
  503. (*     Calling Sequence:                                                *)
  504. (*                                                                      *)
  505. (*        Ansi_Cursor_Down;                                             *)
  506. (*                                                                      *)
  507. (*     Called by:  VT100_Process_Escape                                 *)
  508. (*                                                                      *)
  509. (*----------------------------------------------------------------------*)
  510.  
  511. BEGIN (* Ansi_Cursor_Down *)
  512.  
  513.    IF Escape_Number = 0 THEN
  514.       Reg_Val := 1
  515.    ELSE
  516.       Reg_Val := MAX( 1 , Escape_Register[1] );
  517.  
  518.    GoToXY( Wherex, MIN( WhereY + Reg_Val , 25 ) );
  519.  
  520. END   (* Ansi_Cursor_Down *);
  521.  
  522. (*----------------------------------------------------------------------*)
  523. (*                  Ansi_Cursor_Left --- Move cursor left               *)
  524. (*----------------------------------------------------------------------*)
  525.  
  526. PROCEDURE Ansi_Cursor_Left;
  527.  
  528. (*----------------------------------------------------------------------*)
  529. (*                                                                      *)
  530. (*     Procedure: Ansi_Cursor_Left;                                     *)
  531. (*                                                                      *)
  532. (*     Purpose:   Moves cursor left specified number of columns         *)
  533. (*                                                                      *)
  534. (*     Calling Sequence:                                                *)
  535. (*                                                                      *)
  536. (*        Ansi_Cursor_Left;                                             *)
  537. (*                                                                      *)
  538. (*     Called by:  VT100_Process_Escape                                 *)
  539. (*                                                                      *)
  540. (*----------------------------------------------------------------------*)
  541.  
  542. BEGIN (* Ansi_Cursor_Left *)
  543.  
  544.    IF Escape_Number = 0 THEN
  545.       Reg_Val := 1
  546.    ELSE
  547.       Reg_Val := MAX( 1 , Escape_Register[1] );
  548.  
  549.    GoToXY( MAX( Wherex - Reg_Val , 1 ), WhereY );
  550.  
  551. END   (* Ansi_Cursor_Left *);
  552.  
  553. (*----------------------------------------------------------------------*)
  554. (*                 Ansi_Cursor_Right --- Move cursor right              *)
  555. (*----------------------------------------------------------------------*)
  556.  
  557. PROCEDURE Ansi_Cursor_Right;
  558.  
  559. (*----------------------------------------------------------------------*)
  560. (*                                                                      *)
  561. (*     Procedure: Ansi_Cursor_Right;                                    *)
  562. (*                                                                      *)
  563. (*     Purpose:   Moves cursor right specified number of columns        *)
  564. (*                                                                      *)
  565. (*     Calling Sequence:                                                *)
  566. (*                                                                      *)
  567. (*        Ansi_Cursor_Right;                                            *)
  568. (*                                                                      *)
  569. (*     Called by:  VT100_Process_Escape                                 *)
  570. (*                                                                      *)
  571. (*----------------------------------------------------------------------*)
  572.  
  573. BEGIN (* Ansi_Cursor_Right *)
  574.  
  575.    IF Escape_Number = 0 THEN
  576.       Reg_Val := 1
  577.    ELSE
  578.       Reg_Val := MAX( 1 , Escape_Register[1] );
  579.  
  580.    GoToXY( MIN( WhereX + Reg_Val , 80 ), WhereY );
  581.  
  582. END   (* Ansi_Cursor_Right *);
  583.  
  584. (*----------------------------------------------------------------------*)
  585. (*              Ansi_Status_Report --- Provide terminal status          *)
  586. (*----------------------------------------------------------------------*)
  587.  
  588. PROCEDURE Ansi_Status_Report;
  589.  
  590. (*----------------------------------------------------------------------*)
  591. (*                                                                      *)
  592. (*     Procedure: Ansi_Status_Report;                                   *)
  593. (*                                                                      *)
  594. (*     Purpose:   Provides status reports to host enquiries             *)
  595. (*                                                                      *)
  596. (*     Calling Sequence:                                                *)
  597. (*                                                                      *)
  598. (*        Ansi_Status_Report;                                           *)
  599. (*                                                                      *)
  600. (*     Called by:  VT100_Process_Escape                                 *)
  601. (*                                                                      *)
  602. (*----------------------------------------------------------------------*)
  603.  
  604. VAR
  605.    Istatus  : INTEGER;
  606.    C_Column : STRING[10];
  607.    C_Row    : STRING[10];
  608.  
  609. BEGIN (* Ansi_Status_Report *)
  610.  
  611.    IF Escape_Number = 0 THEN
  612.       Istatus := 5
  613.    ELSE
  614.       Istatus := Escape_Register[ 1 ];
  615.  
  616.    CASE Istatus OF
  617.  
  618.       5:    Async_Send_String( CHR( 27 ) + '[0n' );
  619.  
  620.       6:    BEGIN
  621.                STR( WhereX:3, C_Column );
  622.                STR( WhereY:2, C_Row    );
  623.                Async_Send_String( CHR( 27 ) + '[' +
  624.                                   C_Row + ';' + C_Column + 'R' );
  625.             END;
  626.  
  627.       ELSE;
  628.  
  629.    END   (* CASE *);
  630.  
  631. END   (* Ansi_Status_Report *);
  632.  
  633. (*----------------------------------------------------------------------*)
  634. (*              Ansi_Set_Mode --- Set a terminal mode                   *)
  635. (*----------------------------------------------------------------------*)
  636.  
  637. PROCEDURE Ansi_Set_Mode;
  638.  
  639. (*----------------------------------------------------------------------*)
  640. (*                                                                      *)
  641. (*     Procedure: Ansi_Set_Mode;                                        *)
  642. (*                                                                      *)
  643. (*     Purpose:   Set a terminal mode                                   *)
  644. (*                                                                      *)
  645. (*     Calling Sequence:                                                *)
  646. (*                                                                      *)
  647. (*        Ansi_Set_Mode;                                                *)
  648. (*                                                                      *)
  649. (*     Called by:  VT100_Process_Escape                                 *)
  650. (*                                                                      *)
  651. (*----------------------------------------------------------------------*)
  652.  
  653. VAR
  654.    I: INTEGER;
  655.  
  656. BEGIN (* Ansi_Set_Mode *)
  657.  
  658.    FOR I := 1 TO Escape_Number DO
  659.  
  660.       CASE Escape_Register[I] OF
  661.  
  662.          6:    Origin_Mode    := ON;
  663.  
  664.          7:    Auto_Wrap_Mode := ON;
  665.  
  666.          12:   Local_Echo     := ON;
  667.  
  668.          ELSE;
  669.  
  670.       END   (* CASE *);
  671.  
  672. END   (* Ansi_Set_Mode *);
  673.  
  674. (*----------------------------------------------------------------------*)
  675. (*            Ansi_Reset_Mode --- Set a terminal mode                   *)
  676. (*----------------------------------------------------------------------*)
  677.  
  678. PROCEDURE Ansi_Reset_Mode;
  679.  
  680. (*----------------------------------------------------------------------*)
  681. (*                                                                      *)
  682. (*     Procedure: Ansi_Reset_Mode;                                      *)
  683. (*                                                                      *)
  684. (*     Purpose:   Resets a terminal mode                                *)
  685. (*                                                                      *)
  686. (*     Calling Sequence:                                                *)
  687. (*                                                                      *)
  688. (*        Ansi_Reset_Mode;                                              *)
  689. (*                                                                      *)
  690. (*     Called by:  VT100_Process_Escape                                 *)
  691. (*                                                                      *)
  692. (*----------------------------------------------------------------------*)
  693.  
  694. VAR
  695.    I: INTEGER;
  696.  
  697. BEGIN (* Ansi_Reset_Mode *)
  698.  
  699.    FOR I := 1 TO Escape_Number DO
  700.  
  701.       CASE Escape_Register[I] OF
  702.  
  703.          6:    Origin_Mode    := OFF;
  704.  
  705.          7:    Auto_Wrap_Mode := OFF;
  706.  
  707.          12:   Local_Echo     := OFF;
  708.  
  709.          ELSE;
  710.  
  711.       END   (* CASE *);
  712.  
  713. END   (* Ansi_Reset_Mode *);
  714.  
  715. (*----------------------------------------------------------------------*)
  716. (*         Ansi_Printer_Control --- Sets printer control modes          *)
  717. (*----------------------------------------------------------------------*)
  718.  
  719. PROCEDURE Ansi_Printer_Control;
  720.  
  721. (*----------------------------------------------------------------------*)
  722. (*                                                                      *)
  723. (*     Procedure: Ansi_Printer_Control;                                 *)
  724. (*                                                                      *)
  725. (*     Purpose:   Sets printer control modes                            *)
  726. (*                                                                      *)
  727. (*     Calling Sequence:                                                *)
  728. (*                                                                      *)
  729. (*        Ansi_Printer_Control;                                         *)
  730. (*                                                                      *)
  731. (*     Called by:  VT100_Process_Escape                                 *)
  732. (*                                                                      *)
  733. (*----------------------------------------------------------------------*)
  734.  
  735. VAR
  736.    I: INTEGER;
  737.  
  738. BEGIN (* Ansi_Printer_Control *)
  739.  
  740.    IF Escape_Number > 0 THEN
  741.  
  742.       CASE Escape_Register[1] OF
  743.          4: Auto_Print_Mode := OFF;
  744.          5: Auto_Print_Mode := ON;
  745.       END (* CASE *);
  746.  
  747. END   (* Ansi_Printer_Control *);
  748.  
  749. (*----------------------------------------------------------------------*)
  750. (*            Ansi_Process_Escape --- Process ANSI escape sequence      *)
  751. (*----------------------------------------------------------------------*)
  752.  
  753. PROCEDURE Ansi_Process_Escape( Ch : CHAR );
  754.  
  755. (*----------------------------------------------------------------------*)
  756. (*                                                                      *)
  757. (*     Procedure: Ansi_Process_Escape                                   *)
  758. (*                                                                      *)
  759. (*     Purpose:   Processes escape sequence for BBS/ANSI emulation      *)
  760. (*                                                                      *)
  761. (*     Calling Sequence:                                                *)
  762. (*                                                                      *)
  763. (*        Ansi_Process_Escape( Ch: CHAR );                              *)
  764. (*                                                                      *)
  765. (*           Ch --- Next character in escape sequence                   *)
  766. (*                                                                      *)
  767. (*     Called by:  Emulate_Ansi                                         *)
  768. (*                                                                      *)
  769. (*     Remarks:                                                         *)
  770. (*                                                                      *)
  771. (*        This version doesn't process private DEC escape sequences,    *)
  772. (*        but DOES play music.                                          *)
  773. (*                                                                      *)
  774. (*----------------------------------------------------------------------*)
  775.  
  776. VAR
  777.    Reg_Val     : INTEGER;
  778.    Save_X      : INTEGER;
  779.    Save_Y      : INTEGER;
  780.    More_Escape : BOOLEAN;
  781.  
  782. BEGIN (* Ansi_Process_Escape *)
  783.  
  784.    More_Escape := FALSE;
  785.  
  786.    CASE Ch OF
  787.  
  788.       ' ' : EXIT;
  789.       ^M  : EXIT;
  790.       ^J  : EXIT;
  791.  
  792.       '[' : BEGIN
  793.                Escape_Type    := '[';
  794.                EXIT;
  795.             END;
  796.  
  797.       'f' : Ansi_Set_Cursor;
  798.  
  799.       'H' : Ansi_Set_Cursor;
  800.  
  801.       'J' : Ansi_Clear_Screen;
  802.  
  803.       'K' : Ansi_Clear_Line;
  804.  
  805.       'm' : Ansi_Set_Graphics;
  806.  
  807.       ^N  : IF ( Play_Music_On ) THEN
  808.                PibPlay( Escape_Str );
  809.  
  810.       ELSE  More_Escape := TRUE;
  811.  
  812.    END  (* CASE *);
  813.  
  814.    IF ( NOT More_Escape ) THEN
  815.       Escape_Mode := FALSE
  816.    ELSE
  817.       BEGIN
  818.  
  819.          Ch         := UpCase( Ch );
  820.          Escape_Str := Escape_Str + Ch;
  821.  
  822.          IF Ch IN [ 'A'..'G','L'..'P' ] THEN EXIT;
  823.  
  824.          IF Ch IN [ '0'..'9' ] THEN
  825.             BEGIN
  826.                Escape_Register[Escape_Number] :=
  827.                   ( Escape_Register[Escape_Number] * 10 ) + ORD( Ch ) -
  828.                                                             ORD( '0' );
  829.                EXIT;
  830.             END;
  831.  
  832.          CASE Ch OF
  833.  
  834.             ';', ',' : BEGIN
  835.                           Escape_Number                  := Escape_Number + 1;
  836.                           Escape_Register[Escape_Number] := 0;
  837.                        END;
  838.  
  839.             'T', 'S', '#', '+', '-', '>', '<', '.'
  840.                         : ;
  841.             ELSE
  842.                Escape_Mode := FALSE;
  843.                Ansi_Write_Escape;
  844.  
  845.          END  (* CASE *);
  846.  
  847.    END (* NOT More_Escape *);
  848.  
  849. END   (* Ansi_Process_Escape *);
  850.  
  851. (*----------------------------------------------------------------------*)
  852. (*         VT100_Process_Escape --- Process VT100 escape sequence       *)
  853. (*----------------------------------------------------------------------*)
  854.  
  855. PROCEDURE VT100_Process_Escape( Ch : CHAR );
  856.  
  857. (*----------------------------------------------------------------------*)
  858. (*                                                                      *)
  859. (*     Procedure: VT100_Process_Escape                                  *)
  860. (*                                                                      *)
  861. (*     Purpose:   Processes escape sequence for DEC VT100 emulation     *)
  862. (*                                                                      *)
  863. (*     Calling Sequence:                                                *)
  864. (*                                                                      *)
  865. (*        VT100_Process_Escape( Ch: CHAR );                             *)
  866. (*                                                                      *)
  867. (*           Ch --- Next character in escape sequence                   *)
  868. (*                                                                      *)
  869. (*     Called by:  Emulate_Ansi                                         *)
  870. (*                                                                      *)
  871. (*     Remarks:                                                         *)
  872. (*                                                                      *)
  873. (*        This version processes private DEC escape sequences.          *)
  874. (*                                                                      *)
  875. (*----------------------------------------------------------------------*)
  876.  
  877. VAR
  878.    Reg_Val     : INTEGER;
  879.    Save_X      : INTEGER;
  880.    Save_Y      : INTEGER;
  881.    More_Escape : BOOLEAN;
  882.  
  883. BEGIN (* VT100_Process_Escape *)
  884.  
  885.    More_Escape := FALSE;
  886.  
  887.    CASE Ch OF
  888.  
  889.       ' ' : EXIT;
  890.  
  891.       '#' : IF Escape_Type = ' ' THEN
  892.                BEGIN
  893.                   Escape_Type := '#';
  894.                   EXIT;
  895.                END
  896.             ELSE
  897.                More_Escape := TRUE;
  898.  
  899.       '[' : BEGIN
  900.                Escape_Type    := '[';
  901.                EXIT;
  902.             END;
  903.  
  904.       'f' : Ansi_Set_Cursor;
  905.  
  906.       'H' : Ansi_Set_Cursor;
  907.  
  908.       'J' : Ansi_Clear_Screen;
  909.  
  910.       'K' : Ansi_Clear_Line;
  911.  
  912.       'g' : ClrScr;
  913.  
  914.       'h' : Ansi_Set_Mode;
  915.  
  916.       'i' : Ansi_Printer_Control;
  917.  
  918.       'l' : Ansi_Reset_Mode;
  919.  
  920.       'm' : Ansi_Set_Graphics;
  921.  
  922.       'r' : IF ( Escape_Type = '[' ) THEN
  923.                Ansi_Set_Scrolling_Region;
  924.  
  925.       'c' : Async_Send_String( CHR( 27 ) + '[?1;0c' );
  926.  
  927.       'Z' : IF ( Escape_Type = ' ' ) THEN
  928.                Async_Send_String( CHR( 27 ) + '[?1;0c' );
  929.  
  930.       'n' : Ansi_Status_Report;
  931.  
  932.       '=' : IF ( Escape_Type = ' ' ) THEN
  933.                VT100_Keypad := ON;
  934.  
  935.       '<' : IF ( Escape_Type <> '[' ) THEN
  936.                BEGIN
  937.                   Escape_Mode := FALSE;
  938.                   EXIT;
  939.                END;
  940.  
  941.       '>' : IF ( Escape_Type = ' ' ) THEN
  942.                VT100_Keypad := OFF;
  943.  
  944.       'A' : CASE Escape_Type OF
  945.                ' ': More_Escape := TRUE;
  946.                '[': Ansi_Cursor_Up;
  947.                ELSE;
  948.             END (* CASE *);
  949.  
  950.       'B' : CASE Escape_Type OF
  951.                ' ': More_Escape := TRUE;
  952.                '[': Ansi_Cursor_Down;
  953.                ELSE;
  954.             END (* CASE *);
  955.  
  956.       'C' : CASE Escape_Type OF
  957.                ' ': More_Escape := TRUE;
  958.                '[': Ansi_Cursor_Right;
  959.                ELSE;
  960.             END (* CASE *);
  961.  
  962.       'D' : CASE Escape_Type OF
  963.  
  964.                ' ': BEGIN
  965.                        IF WhereY < 25 THEN
  966.                           GoToXY( WhereX , WhereY + 1 )
  967.                        ELSE
  968.                           BEGIN
  969.                              Save_X := WhereX;
  970.                              Save_Y := WhereY;
  971.                              InsLine;
  972.                              GoToXY( Save_X, Save_Y );
  973.                           END;
  974.                     END;
  975.  
  976.                '[': Ansi_Cursor_Left;
  977.  
  978.                ELSE;
  979.  
  980.             END (* CASE *);
  981.  
  982.       '3' : IF Escape_Type <> '#' THEN More_Escape := TRUE;
  983.  
  984.       '4' : IF Escape_Type <> '#' THEN More_Escape := TRUE;
  985.  
  986.       '5' : IF Escape_Type = '#' THEN
  987.                Double_Width_Mode := OFF
  988.             ELSE
  989.                More_Escape := TRUE;
  990.  
  991.       '6' : IF Escape_Type = '#' THEN
  992.                Double_Width_Mode := ON
  993.             ELSE
  994.                More_Escape := TRUE;
  995.  
  996.       '7' : CASE Escape_Type OF
  997.  
  998.                ' ': BEGIN
  999.                        Save_Row_Position := WhereX;
  1000.                        Save_Col_Position := WhereY;
  1001.                        Save_FG_Color     := FG;
  1002.                        Save_BG_Color     := BG;
  1003.                     END;
  1004.                 ELSE More_Escape := TRUE;
  1005.  
  1006.             END (* CASE *);
  1007.  
  1008.       '8' : CASE Escape_Type OF
  1009.  
  1010.                ' ': BEGIN
  1011.                        GoToXY( Save_Row_Position , Save_Col_Position );
  1012.                        FG := Save_FG_Color;
  1013.                        BG := Save_BG_Color;
  1014.                        TextColor( FG );
  1015.                        TextBackGround( BG );
  1016.                     END;
  1017.  
  1018.                ELSE More_Escape := TRUE;
  1019.  
  1020.             END (* CASE *);
  1021.  
  1022.       ')' : IF ( Escape_Type <> '[' ) THEN
  1023.                BEGIN
  1024.                   VT100_Graphics_Mode := FALSE;
  1025.                   Ch := Ansi_Next_Char;
  1026.                END;
  1027.  
  1028.       '(' : IF ( Escape_Type <> '[' ) THEN
  1029.                BEGIN
  1030.                   Escape_Type := '(';
  1031.                   Ch := Ansi_Next_Char;
  1032.                   VT100_Graphics_Mode := ( Ch = '0' ) AND VT100_Allowed;
  1033.                END;
  1034.  
  1035.       'E' : IF ( Escape_Type <> '[' ) THEN
  1036.                IF ( WhereY >= Top_Scroll    ) AND
  1037.                   ( WhereY <= Bottom_Scroll ) THEN
  1038.                   BEGIN
  1039.                      Window( 1, Top_Scroll, 80, Bottom_Scroll );
  1040.                      WRITELN;
  1041.                      Window( 1, 1, 80, 25 );
  1042.                   END
  1043.                ELSE
  1044.                   WRITELN;
  1045.  
  1046.       'M' : IF ( Escape_Type <> '[' ) THEN
  1047.                BEGIN
  1048.                   IF WhereY > Top_Scroll THEN
  1049.                      GoToXY( WhereX , WhereY - 1 )
  1050.                   ELSE
  1051.                      BEGIN
  1052.                         Save_X := WhereX;
  1053.                         Save_Y := WhereY;
  1054.                         Window( 1, Top_Scroll, 80, Bottom_Scroll );
  1055.                         InsLine;
  1056.                         Window( 1, 1, 80, 25 );
  1057.                         GoToXY( Save_X, Save_Y );
  1058.                      END;
  1059.                END;
  1060.  
  1061.       ELSE   More_Escape := TRUE;
  1062.  
  1063.    END  (* CASE *);
  1064.  
  1065.    IF ( NOT More_Escape ) THEN
  1066.       Escape_Mode := FALSE
  1067.    ELSE
  1068.       BEGIN
  1069.  
  1070.          Ch         := UpCase( Ch );
  1071.          Escape_Str := Escape_Str + Ch;
  1072.  
  1073.          IF Ch IN [ 'A'..'G','L'..'P' ] THEN EXIT;
  1074.  
  1075.          IF Ch IN [ '0'..'9' ] THEN
  1076.             BEGIN
  1077.                Escape_Register[Escape_Number] :=
  1078.                   ( Escape_Register[Escape_Number] * 10 ) + ORD( Ch ) -
  1079.                                                             ORD( '0' );
  1080.                EXIT;
  1081.             END;
  1082.  
  1083.          CASE Ch OF
  1084.  
  1085.             ';', ',' : BEGIN
  1086.                           Escape_Number                  := Escape_Number + 1;
  1087.                           Escape_Register[Escape_Number] := 0;
  1088.                        END;
  1089.  
  1090.             'T', 'S', '#', '+', '-', '>', '<', '.','?','='
  1091.                         : ;
  1092.             ELSE
  1093.                Escape_Mode := FALSE;
  1094.                Ansi_Write_Escape;
  1095.  
  1096.          END  (* Case *);
  1097.  
  1098.       END (* NOT More_Escape *);
  1099.  
  1100. END   (* VT100_Process_Escape *);
  1101.  
  1102. (*----------------------------------------------------------------------*)
  1103. (*       Ansi_Set_Input_Keys --- Set input key mapping for ANSI mode    *)
  1104. (*----------------------------------------------------------------------*)
  1105.  
  1106. PROCEDURE Ansi_Set_Input_Keys;
  1107.  
  1108. (*----------------------------------------------------------------------*)
  1109. (*                                                                      *)
  1110. (*     Procedure: Ansi_Set_Input_Keys                                   *)
  1111. (*                                                                      *)
  1112. (*     Purpose:   Provides conversion string from PC keys to VT100      *)
  1113. (*                                                                      *)
  1114. (*     Calling Sequence:                                                *)
  1115. (*                                                                      *)
  1116. (*        Ansi_Set_Input_Keys;                                          *)
  1117. (*                                                                      *)
  1118. (*     Calls:                                                           *)
  1119. (*                                                                      *)
  1120. (*        None                                                          *)
  1121. (*                                                                      *)
  1122. (*     Called by:  Emulate_Ansi                                         *)
  1123. (*                                                                      *)
  1124. (*     Remarks:                                                         *)
  1125. (*                                                                      *)
  1126. (*        This routine defines the strings to be sent to the host when  *)
  1127. (*        a keyboard key is depressed.                                  *)
  1128. (*                                                                      *)
  1129. (*----------------------------------------------------------------------*)
  1130.  
  1131. CONST
  1132.    Esc_Char = ^[;
  1133.  
  1134. VAR
  1135.    I: INTEGER;
  1136.    J: INTEGER;
  1137.  
  1138. BEGIN (* Ansi_Set_Input_Keys *)
  1139.                                    (* Make sure the arrows at least are set *)
  1140.  
  1141.    J := Keypad_Key_Index[U_Arrow];
  1142.    I := ( J - 1 ) DIV 10 + 1;
  1143.    J := J - ( I - 1 ) * 10;
  1144.  
  1145.    IF Keypad_Keys[I,J] = '' THEN
  1146.       Keypad_Keys[I,J] := Esc_Char + '[A';
  1147.  
  1148.    J := Keypad_Key_Index[D_Arrow];
  1149.    I := ( J - 1 ) DIV 10 + 1;
  1150.    J := J - ( I - 1 ) * 10;
  1151.  
  1152.    IF Keypad_Keys[I,J] = '' THEN
  1153.       Keypad_Keys[I,J] := Esc_Char + '[B';
  1154.  
  1155.    J := Keypad_Key_Index[L_Arrow];
  1156.    I := ( J - 1 ) DIV 10 + 1;
  1157.    J := J - ( I - 1 ) * 10;
  1158.  
  1159.    IF Keypad_Keys[I,J] = '' THEN
  1160.       Keypad_Keys[I,J] := Esc_Char + '[D';
  1161.  
  1162.    J := Keypad_Key_Index[R_Arrow];
  1163.    I := ( J - 1 ) DIV 10 + 1;
  1164.    J := J - ( I - 1 ) * 10;
  1165.  
  1166.    IF Keypad_Keys[I,J] = '' THEN
  1167.       Keypad_Keys[I,J] := Esc_Char + '[C';
  1168.  
  1169. END   (* Ansi_Set_Input_Keys *);
  1170.  
  1171. (*----------------------------------------------------------------------*)
  1172.  
  1173. BEGIN (* Emulate_ANSI *)
  1174.                                    (* Indicate ANSI/VT100 being simulated *)
  1175.    Save_Screen( Saved_Screen );
  1176.    Draw_Menu_Frame( 10, 10, 55, 15, Menu_Frame_Color,
  1177.                     Menu_Text_Color, '' );
  1178.  
  1179.    IF VT100_Allowed THEN
  1180.       WRITELN('Emulating VT100 Terminal')
  1181.    ELSE
  1182.       WRITELN('Emulating BBS/ANSI Terminal');
  1183.  
  1184.    DELAY( One_Second_Delay );
  1185.  
  1186.    Restore_Screen( Saved_Screen );
  1187.    Reset_Global_Colors;
  1188.  
  1189.                                    (* Initialize terminal state     *)
  1190.    Done                  := FALSE;
  1191.    VT100_Keypad          := OFF;
  1192.    VT100_Graphics_Mode   := OFF;
  1193.    Auto_Print_Mode       := OFF;
  1194.    Origin_Mode           := OFF;
  1195.    Auto_Wrap_Mode        := ON;
  1196.    Printer_Ctrl_Mode     := OFF;
  1197.    Escape_Mode           := FALSE;
  1198.    Escape_Str            := '';
  1199.    NewX                  := WhereX;
  1200.    NewY                  := WhereY;
  1201.  
  1202.                                    (* Initial scrolling region is *)
  1203.                                    (* entire screen.              *)
  1204.    Top_Scroll            := 1;
  1205.    Bottom_Scroll         := 24;
  1206.                                    (* Background, foreground      *)
  1207.  
  1208.    Save_Global_FG        := Global_ForeGround_Color;
  1209.    Save_Global_BG        := Global_BackGround_Color;
  1210.    Save_FG               := ForeGround_Color;
  1211.    Save_BG               := BackGround_Color;
  1212.  
  1213.                                    (* Set colors.                *)
  1214.    IF( NOT VT100_Allowed ) THEN
  1215.       BEGIN
  1216.  
  1217.          White_Shade           := LIGHTGRAY;
  1218.          Ansi_ForeGround_Color := LIGHTGRAY;
  1219.          Ansi_BackGround_Color := BLACK;
  1220.          Ansi_Underline_Color  := BLUE;
  1221.          Ansi_Bold_Color       := WHITE;
  1222.  
  1223.          ForeGround_Color      := LIGHTGRAY;
  1224.          BackGround_Color      := BLACK;
  1225.  
  1226.          FG                    := LIGHTGRAY;
  1227.          BG                    := BLACK;
  1228.  
  1229.       END
  1230.    ELSE
  1231.       BEGIN
  1232.  
  1233.          White_Shade           := VT100_ForeGround_Color;
  1234.          Ansi_ForeGround_Color := VT100_ForeGround_Color;
  1235.          Ansi_BackGround_Color := VT100_BackGround_Color;
  1236.          Ansi_Underline_Color  := VT100_Underline_Color;
  1237.          Ansi_Bold_Color       := VT100_Bold_Color;
  1238.  
  1239.          ForeGround_Color      := VT100_ForeGround_Color;
  1240.          BackGround_Color      := VT100_BackGround_Color;
  1241.  
  1242.          FG                    := VT100_ForeGround_Color;
  1243.          BG                    := VT100_BackGround_Color;
  1244.  
  1245.       END;
  1246.  
  1247.    Set_Global_Colors( Ansi_ForeGround_Color , Ansi_BackGround_Color );
  1248.  
  1249.                                    (* Initialize music playing   *)
  1250.    PibPlaySet;
  1251.                                    (* Set up input key mapping   *)
  1252.    Ansi_Set_Input_Keys;
  1253.                                    (* Loop over input until done *)
  1254.    WHILE ( NOT Done ) DO
  1255.       BEGIN
  1256.  
  1257.          IF KeyPressed THEN
  1258.             BEGIN (* KeyPressed *)
  1259.  
  1260.                READ( Kbd , Comm_Ch );
  1261.  
  1262.                CASE ORD( Comm_Ch ) OF
  1263.  
  1264.                   ESC:  IF KeyPressed THEN
  1265.                            BEGIN
  1266.                               Process_Command( Comm_Ch, FALSE, PibTerm_Command );
  1267.                               IF PibTerm_Command <> Null_Command THEN
  1268.                                  Execute_Command( PibTerm_Command, Done, FALSE );
  1269.                            END
  1270.                         ELSE
  1271.                            BEGIN
  1272.                               IF Local_Echo THEN WRITE( Comm_Ch );
  1273.                               Async_Send( Comm_Ch );
  1274.                            END;
  1275.  
  1276.                   BS:   BEGIN
  1277.                            Comm_Ch := BS_Char;
  1278.                            IF Local_Echo THEN WRITE( Comm_Ch );
  1279.                            Async_Send( Comm_Ch );
  1280.                         END;
  1281.  
  1282.                   DEL:  BEGIN
  1283.                            Comm_Ch := Ctrl_BS_Char;
  1284.                            IF Local_Echo THEN WRITE( Comm_Ch );
  1285.                            Async_Send( Comm_Ch );
  1286.                         END;
  1287.  
  1288.                   ELSE
  1289.                         BEGIN
  1290.                            IF Local_Echo THEN WRITE( Comm_Ch );
  1291.                            Async_Send( Comm_Ch );
  1292.                         END;
  1293.  
  1294.                END (* CASE ORD( Comm_Ch ) *);
  1295.  
  1296.             END (* KeyPressed *);
  1297.  
  1298.          IF ( Script_File_Mode AND ( NOT ( Done OR Really_Wait_String ) ) ) THEN
  1299.             BEGIN
  1300.                Get_Script_Command( PibTerm_Command );
  1301.                Execute_Command   ( PibTerm_Command , Done , TRUE );
  1302.             END;
  1303.  
  1304.          IF Async_Receive( Comm_Ch ) THEN
  1305.  
  1306.             BEGIN  (* Comm_Ch found *)
  1307.  
  1308.                Async_Buffer_Full;
  1309.  
  1310.                Comm_Ch := TrTab[ Comm_Ch ];
  1311.  
  1312.                IF Comm_Ch = CHR( ESC ) THEN
  1313.                   BEGIN (* ESC found *)
  1314.  
  1315.                      IF Escape_Mode THEN Ansi_Write_Escape;
  1316.  
  1317.                      Escape_Str         := '';
  1318.                      Escape_Number      := 1;
  1319.                      Escape_Register[1] := 0;
  1320.                      Escape_Mode        := TRUE;
  1321.                      Escape_Type        := ' ';
  1322.  
  1323.                   END
  1324.  
  1325.                ELSE IF Escape_Mode THEN
  1326.  
  1327.                   CASE VT100_Allowed OF
  1328.                      TRUE:   VT100_Process_Escape( Comm_Ch );
  1329.                      FALSE:  Ansi_Process_Escape( Comm_Ch );
  1330.                   END (* CASE *)
  1331.  
  1332.                ELSE
  1333.  
  1334.                   CASE ORD( Comm_Ch ) OF
  1335.  
  1336.                      LF,
  1337.                      FF,
  1338.                      VT:   BEGIN (* go down one line *)
  1339.  
  1340.                               IF ( WhereY = Bottom_Scroll ) THEN
  1341.                                  BEGIN
  1342.                                     Window( 1, Top_Scroll, 80, Bottom_Scroll );
  1343.                                     Display_Character( CHR( LF ) );
  1344.                                     Window( 1, 1, 80, 25 );
  1345.                                  END
  1346.                               ELSE
  1347.                                  Display_Character( CHR( LF ) );
  1348.  
  1349.                               IF Auto_Print_Mode THEN
  1350.                                  BEGIN
  1351.                                     Get_Screen_Text_Line( Print_Line, WhereY - 1,
  1352.                                                           1 );
  1353.                                     WRITELN( Lst , Print_Line );
  1354.                                  END;
  1355.  
  1356.                            END   (* go down one line *);
  1357.  
  1358.                      HT:   BEGIN (* Convert tabs to sequence of blanks *)
  1359. (*
  1360.                               Curcol := WhereX;
  1361.                               Itab   := 1;
  1362.                               WHILE( Curcol > VT100_Tabs[Itab] ) DO
  1363.                                  Itab := Itab + 1;
  1364.                               Tabcol := VT100_Tabs[Itab];
  1365.                               FOR Itab := Curcol To ( Tabcol - 1 ) DO
  1366.                                  WRITE(' ');
  1367. *)
  1368.                               Display_Character( Comm_Ch );
  1369.                            END   (* Tabs *);
  1370.  
  1371.                      SO:   IF VT100_Allowed THEN
  1372.                               VT100_Graphics_Mode := ON;
  1373.  
  1374.                      SI:   IF VT100_Allowed THEN
  1375.                               VT100_Graphics_Mode := OFF;
  1376.  
  1377.                                    (* CompuServe B protocol request *)
  1378.  
  1379.                      ENQ:  IF CompuServe_B_On THEN
  1380.                               B := Do_CompuServe_B_Transfer
  1381.                            ELSE
  1382.                               Display_Character( Comm_Ch );
  1383.  
  1384.                      ELSE
  1385.                         IF NOT VT100_Graphics_Mode THEN
  1386.                            Display_Character( Comm_Ch )
  1387.                         ELSE
  1388.                            BEGIN (* Graphics Mode *)
  1389.                               IF ORD( Comm_Ch ) IN [ 95 .. 126 ] THEN
  1390.                                  BEGIN
  1391.                                     Graph_Ch := Graphics_Chars[ ORD( Comm_Ch ) ];
  1392.                                     Display_Character( CHR( Graph_Ch ) );
  1393.                                  END
  1394.                               ELSE
  1395.                                  Display_Character( Comm_Ch );
  1396.                            END   (* Graphics Mode *);
  1397.  
  1398.                   END (* CASE ORD( Comm_Ch ) *);
  1399.  
  1400.             END (* Comm_Ch found *);
  1401.  
  1402.       END  (* NOT Done *);
  1403.                                    (* Restore colors *)
  1404.  
  1405.    ForeGround_Color        := Save_FG;
  1406.    BackGround_Color        := Save_BG;
  1407.  
  1408.    Set_Global_Colors( ForeGround_Color , BackGround_Color );
  1409.  
  1410. END   (* Emulate_ANSI *);
  1411.